﻿using System.Text;

using BodaNetCommunications.Utilities.ComTypes;

namespace BodaNetCommunications.Cores
{

    //
    // 摘要:
    //     支持转换器的基础接口，规定了实际的数据类型和字节数组进行相互转换的方法。主要为System.Boolean,System.Byte,System.Int16,System.UInt16,System.Int32,System.UInt32,
    //     System.Int64,System.UInt64,System.Single,System.Double,System.String之间的变换关系
    //     Support the basic interface of the converter, and stipulate the method of mutual
    //     conversion between actual data types and byte arrays. Mainly System.Boolean,System.Byte,
    //     System.Int16,System.UInt16,System.Int32,System.UInt32,System.Int64,System.UInt64,System.Single,System.Double,
    //     System.StringThe transformation relationship between
    //
    // 言论：
    //     所有的设备通讯类都内置了该转换的模型，并且已经配置好数据的高地位模式，可以方便的转换信息，当然您也可以手动修改Core.IByteTransform.EndianType属性来满足更加特殊的场景
    //
    //     All device communication classes have a built-in conversion model, and the high-status
    //     mode of the data has been configured, which can easily convert the information.
    //     Of course, you can also manually modify the Core.IByteTransform.EndianType
    //     attribute to meet more special requirements.
    public interface IByteTransform
    {
        //
        // 摘要:
        //     获取或设置数据解析的格式，可选ABCD, BADC，CDAB，DCBA格式，对int,uint,float,double,long,ulong类型有作用
        //
        //     Get or set the format of the data analysis, optional ABCD, BADC, CDAB, DCBA format,
        //     effective for int, uint, float, double, long, ulong type
        EndianType EndianType { get; set; }

        //
        // 摘要:
        //     获取或设置在解析字符串的时候是否将字节按照字单位反转
        //     Gets or sets whether to reverse the bytes in word units when parsing strings
        bool IsStringReverseByteWord { get; set; }

        /// <summary>
        /// 通过地址，获取数据类型
        /// </summary>
        /// <param name="address"></param>
        /// <param name="addressType"></param>
        /// <returns></returns>
        bool AnalysyseAddresType(ref string address, out Type addressType);

        /// <summary>
        /// 根据输入的地址和数据类型，转换成正确的数值类型
        /// 为了方式地址是双字，值是short类型，根据地址将short类型的值转换为int类型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        Type AnalysyseAddres<T>(string address, T value);

        byte[] AnalysyseAddresAdndGetBytes<T>(string address, T value);

        //
        // 摘要:
        //     从缓存中提取出bool结果，需要传入想要提取的位索引，注意：是从0开始的位索引，10则表示 buffer[1] 的第二位。
        //     To extract the bool result from the cache, you need to pass in the bit index
        //     you want to extract. Note: the bit index starts from 0, and 10 represents the
        //     second bit of buffer[1].
        //
        // 参数:
        //   buffer:
        //     等待提取的缓存数据
        //
        //   index:
        //     位的索引，注意：是从0开始的位索引，10则表示 buffer[1] 的第二位。
        //
        // 返回结果:
        //     表示不是 true 就是 false 的 bool 数据
        bool TransBool(byte[] buffer, int index);

        //
        // 摘要:
        //     从缓存中提取出bool数组结果，需要传入想要提取的位索引，注意：是从0开始的位索引，10则表示 buffer[1] 的第二位。长度为 bool 数量的长度，传入
        //     10 则获取 10 个长度的 bool[] 数组。
        //     To extract the result of the bool array from the cache, you need to pass in the
        //     bit index you want to extract. Note: the bit index starts from 0, and 10 represents
        //     the second bit of buffer[1]. The length is the length of the number of bools.
        //     If you pass in 10, you will get a bool[] array of 10 lengths.
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     位的起始索引，需要传入想要提取的位索引，注意：是从0开始的位索引，10则表示 buffer[1] 的第二位
        //
        //   length:
        //     读取的 bool 长度，按照位为单位，传入 10 则表示获取 10 个长度的 bool[]
        //
        // 返回结果:
        //     bool数组
        bool[] TransBool(byte[] buffer, int index, int length);

        //
        // 摘要:
        //     从缓存中提取byte结果，需要指定起始的字节索引
        //     To extract the byte result from the cache, you need to specify the starting byte
        //     index
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        // 返回结果:
        //     byte对象
        byte TransByte(byte[] buffer, int index);

        //
        // 摘要:
        //     从缓存中提取byte数组结果，需要指定起始的字节索引，以及指定读取的字节长度
        //     To extract the byte array result from the cache, you need to specify the starting
        //     byte index and the byte length to be read
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   length:
        //     读取的数组长度
        //
        // 返回结果:
        //     byte数组对象
        byte[] TransByte(byte[] buffer, int index, int length);

        //
        // 摘要:
        //     从缓存中提取short结果，需要指定起始的字节索引，按照字节为单位，一个short占用两个字节
        //     To extract short results from the cache, you need to specify the starting byte
        //     index, in bytes, A short occupies two bytes
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        // 返回结果:
        //     short对象
        short TransInt16(byte[] buffer, int index);

        //
        // 摘要:
        //     从缓存中提取short数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 short 数组的长度，如果传入 10 ，则表示提取 10 个连续的
        //     short 数据，该数据共占用 20 字节。
        //     To extract the result of the short array from the cache, you need to specify
        //     the starting byte index, in bytes, and then specify the length of the extracted
        //     short array. If 10 is passed in, it means to extract 10 consecutive short data.
        //     Occupies 20 bytes.
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   length:
        //     读取的数组长度
        //
        // 返回结果:
        //     short数组对象
        short[] TransInt16(byte[] buffer, int index, int length);

        //
        // 摘要:
        //     从缓存中提取short二维数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 short 数组的行和列的长度，按照 short 为单位的个数。
        //
        //     To extract the result of a short two-dimensional array from the cache, you need
        //     to specify the starting byte index, in bytes, and then specify the length of
        //     the rows and columns of the extracted short array, in terms of the number of
        //     shorts.
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   row:
        //     二维数组行
        //
        //   col:
        //     二维数组列
        //
        // 返回结果:
        //     二维short数组
        short[,] TransInt16(byte[] buffer, int index, int row, int col);

        //
        // 摘要:
        //     从缓存中提取ushort结果，需要指定起始的字节索引，按照字节为单位，一个ushort占用两个字节
        //     To extract ushort results from the cache, you need to specify the starting byte
        //     index, in bytes, A ushort occupies two bytes
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        // 返回结果:
        //     ushort对象
        ushort TransUInt16(byte[] buffer, int index);

        //
        // 摘要:
        //     从缓存中提取ushort数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 ushort 数组的长度，如果传入 10 ，则表示提取 10 个连续的
        //     ushort 数据，该数据共占用 20 字节。
        //     To extract the ushort array result from the cache, you need to specify the starting
        //     byte index, in bytes, and then specify the length of the extracted ushort array.
        //     If 10 is passed in, it means to extract 10 consecutive ushort data. Occupies
        //     20 bytes.
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   length:
        //     读取的数组长度
        //
        // 返回结果:
        //     ushort数组对象
        ushort[] TransUInt16(byte[] buffer, int index, int length);

        //
        // 摘要:
        //     从缓存中提取ushort二维数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 ushort 数组的行和列的长度，按照 ushort 为单位的个数。
        //
        //     To extract the result of the ushort two-dimensional array from the cache, you
        //     need to specify the starting byte index, in bytes, and then specify the length
        //     of the rows and columns of the extracted ushort array, in terms of the number
        //     of ushorts.
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   row:
        //     二维数组行
        //
        //   col:
        //     二维数组列
        //
        // 返回结果:
        //     二维ushort数组
        ushort[,] TransUInt16(byte[] buffer, int index, int row, int col);

        //
        // 摘要:
        //     从缓存中提取int结果，需要指定起始的字节索引，按照字节为单位，一个int占用四个字节
        //     To extract the int result from the cache, you need to specify the starting byte
        //     index, in bytes, A int occupies four bytes
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        // 返回结果:
        //     int对象
        int TransInt32(byte[] buffer, int index);

        //
        // 摘要:
        //     从缓存中提取int数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 int 数组的长度，如果传入 10 ，则表示提取 10 个连续的 int
        //     数据，该数据共占用 40 字节。
        //     To extract the int array result from the cache, you need to specify the starting
        //     byte index, in bytes, and then specify the length of the extracted int array.
        //     If 10 is passed in, it means to extract 10 consecutive int data. Occupies 40
        //     bytes.
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   length:
        //     读取的数组长度
        //
        // 返回结果:
        //     int数组对象
        int[] TransInt32(byte[] buffer, int index, int length);

        //
        // 摘要:
        //     从缓存中提取int二维数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 int 数组的行和列的长度，按照 int 为单位的个数。
        //     To extract the result of an int two-dimensional array from the cache, you need
        //     to specify the starting byte index, in bytes, and then specify the length of
        //     the rows and columns of the extracted int array, in the number of int units.
        //
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   row:
        //     二维数组行
        //
        //   col:
        //     二维数组列
        //
        // 返回结果:
        //     二维int数组
        int[,] TransInt32(byte[] buffer, int index, int row, int col);

        //
        // 摘要:
        //     从缓存中提取uint结果，需要指定起始的字节索引，按照字节为单位，一个uint占用四个字节
        //     To extract uint results from the cache, you need to specify the starting byte
        //     index, in bytes, A uint occupies four bytes
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        // 返回结果:
        //     uint对象
        uint TransUInt32(byte[] buffer, int index);

        //
        // 摘要:
        //     从缓存中提取uint数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 uint 数组的长度，如果传入 10 ，则表示提取 10 个连续的
        //     uint 数据，该数据共占用 40 字节。
        //     To extract the uint array result from the cache, you need to specify the starting
        //     byte index, in bytes, and then specify the length of the extracted uint array.
        //     If 10 is passed in, it means to extract 10 consecutive uint data. Occupies 40
        //     bytes.
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   length:
        //     读取的数组长度
        //
        // 返回结果:
        //     uint数组对象
        uint[] TransUInt32(byte[] buffer, int index, int length);

        //
        // 摘要:
        //     从缓存中提取uint二维数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 uint 数组的行和列的长度，按照 uint 为单位的个数。
        //     To extract the result of a uint two-dimensional array from the cache, you need
        //     to specify the starting byte index, in bytes, and then specify the length of
        //     the rows and columns of the extracted uint array, in terms of uint as the unit.
        //
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   row:
        //     二维数组行
        //
        //   col:
        //     二维数组列
        //
        // 返回结果:
        //     uint二维数组对象
        uint[,] TransUInt32(byte[] buffer, int index, int row, int col);

        //
        // 摘要:
        //     从缓存中提取long结果，需要指定起始的字节索引，按照字节为单位，一个long占用八个字节
        //     To extract the long result from the cache, you need to specify the starting byte
        //     index, in bytes, A long occupies eight bytes
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        // 返回结果:
        //     long对象
        long TransInt64(byte[] buffer, int index);

        //
        // 摘要:
        //     从缓存中提取long数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 long 数组的长度，如果传入 10 ，则表示提取 10 个连续的
        //     long 数据，该数据共占用 80 字节。
        //     To extract the long array result from the cache, you need to specify the starting
        //     byte index, in bytes, and then specify the length of the long array to be extracted.
        //     If 10 is passed in, it means to extract 10 consecutive long data. Occupies 80
        //     bytes.
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   length:
        //     读取的数组长度
        //
        // 返回结果:
        //     long数组对象
        long[] TransInt64(byte[] buffer, int index, int length);

        //
        // 摘要:
        //     从缓存中提取long二维数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 long 数组的行和列的长度，按照 long 为单位的个数。
        //     To extract the result of a long two-dimensional array from the cache, you need
        //     to specify the starting byte index, in bytes, and then specify the length of
        //     the rows and columns of the extracted long array, in long as the number of units.
        //
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   row:
        //     二维数组行
        //
        //   col:
        //     二维数组列
        //
        // 返回结果:
        //     long二维数组对象
        long[,] TransInt64(byte[] buffer, int index, int row, int col);

        //
        // 摘要:
        //     从缓存中提取ulong结果，需要指定起始的字节索引，按照字节为单位，一个ulong占用八个字节 To extract the ulong result from
        //     the cache, you need to specify the starting byte index, in bytes, A ulong occupies
        //     eight bytes
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        // 返回结果:
        //     ulong对象
        ulong TransUInt64(byte[] buffer, int index);

        //
        // 摘要:
        //     从缓存中提取ulong数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 ulong 数组的长度，如果传入 10 ，则表示提取 10 个连续的
        //     ulong 数据，该数据共占用 80 字节。
        //     To extract the ulong array result from the cache, you need to specify the starting
        //     byte index, in bytes, and then specify the length of the extracted ulong array.
        //     If 10 is passed in, it means to extract 10 consecutive ulong data. Occupies 80
        //     bytes.
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   length:
        //     读取的数组长度
        //
        // 返回结果:
        //     ulong数组对象
        ulong[] TransUInt64(byte[] buffer, int index, int length);

        //
        // 摘要:
        //     从缓存中提取ulong二维数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 ulong 数组的行和列的长度，按照 ulong 为单位的个数。
        //
        //     To extract the result of the ulong two-dimensional array from the cache, you
        //     need to specify the starting byte index, in bytes, and then specify the length
        //     of the rows and columns of the extracted ulong array, in the number of ulong
        //     units.
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   row:
        //     二维数组行
        //
        //   col:
        //     二维数组列
        //
        // 返回结果:
        //     ulong二维数组对象
        ulong[,] TransUInt64(byte[] buffer, int index, int row, int col);

        //
        // 摘要:
        //     从缓存中提取float结果，需要指定起始的字节索引，按照字节为单位，一个float占用四个字节 To extract the float result from
        //     the cache, you need to specify the starting byte index, in units of bytes, A
        //     float occupies four bytes
        //
        // 参数:
        //   buffer:
        //     缓存对象
        //
        //   index:
        //     索引位置
        //
        // 返回结果:
        //     float对象
        float TransSingle(byte[] buffer, int index);

        //
        // 摘要:
        //     从缓存中提取float数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 float 数组的长度，如果传入 10 ，则表示提取 10 个连续的
        //     float 数据，该数据共占用 40 字节。
        //     To extract the result of the float array from the cache, you need to specify
        //     the starting byte index, in bytes, and then specify the length of the extracted
        //     float array. If 10 is passed in, it means that 10 consecutive float data are
        //     extracted. Occupies 40 bytes.
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   length:
        //     读取的数组长度
        //
        // 返回结果:
        //     float数组
        float[] TransSingle(byte[] buffer, int index, int length);

        //
        // 摘要:
        //     从缓存中提取float二维数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 float 数组的行和列的长度，按照 float 为单位的个数。
        //
        //     To extract the result of a float two-dimensional array from the cache, you need
        //     to specify the starting byte index, in bytes, and then specify the length of
        //     the rows and columns of the extracted float array, in terms of the number of
        //     floats.
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   row:
        //     二维数组行
        //
        //   col:
        //     二维数组列
        //
        // 返回结果:
        //     float二维数组对象
        float[,] TransSingle(byte[] buffer, int index, int row, int col);

        //
        // 摘要:
        //     从缓存中提取double结果，需要指定起始的字节索引，按照字节为单位，一个double占用八个字节
        //     To extract the double result from the cache, you need to specify the starting
        //     byte index, in bytes, A double occupies eight bytes
        //
        // 参数:
        //   buffer:
        //     缓存对象
        //
        //   index:
        //     索引位置
        //
        // 返回结果:
        //     double对象
        double TransDouble(byte[] buffer, int index);

        //
        // 摘要:
        //     从缓存中提取double数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 double 数组的长度，如果传入 10 ，则表示提取 10 个连续的
        //     double 数据，该数据共占用 80 字节。
        //     To extract the double array result from the cache, you need to specify the starting
        //     byte index, in bytes, and then specify the length of the extracted double array.
        //     If 10 is passed in, it means to extract 10 consecutive double data. Occupies
        //     80 bytes.
        //
        // 参数:
        //   buffer:
        //     缓存对象
        //
        //   index:
        //     索引位置
        //
        //   length:
        //     读取的数组长度
        //
        // 返回结果:
        //     double数组
        double[] TransDouble(byte[] buffer, int index, int length);

        //
        // 摘要:
        //     从缓存中提取double二维数组结果，需要指定起始的字节索引，按照字节为单位，然后指定提取的 double 数组的行和列的长度，按照 double 为单位的个数。
        //
        //     To extract the result of a double two-dimensional array from the cache, you need
        //     to specify the starting byte index, in bytes, and then specify the length of
        //     the rows and columns of the extracted double array, in terms of the number of
        //     doubles.
        //
        // 参数:
        //   buffer:
        //     缓存数据
        //
        //   index:
        //     索引位置
        //
        //   row:
        //     二维数组行
        //
        //   col:
        //     二维数组列
        //
        // 返回结果:
        //     double二维数组对象
        double[,] TransDouble(byte[] buffer, int index, int row, int col);

        //
        // 摘要:
        //     从缓存中提取string结果，使用指定的编码将全部的缓存转为字符串
        //     Extract the string result from the cache, use the specified encoding to convert
        //     all the cache into a string
        //
        // 参数:
        //   buffer:
        //     缓存对象
        //
        //   encoding:
        //     字符串的编码
        //
        // 返回结果:
        //     string对象
        string TransString(byte[] buffer, Encoding encoding);

        //
        // 摘要:
        //     从缓存中的部分字节数组转化为string结果，使用指定的编码，指定起始的字节索引，字节长度信息。
        //     Convert a part of the byte array in the buffer into a string result, use the
        //     specified encoding, specify the starting byte index, and byte length information.
        //
        //
        // 参数:
        //   buffer:
        //     缓存对象
        //
        //   index:
        //     索引位置
        //
        //   length:
        //     byte数组长度
        //
        //   encoding:
        //     字符串的编码
        //
        // 返回结果:
        //     string对象
        string TransString(byte[] buffer, int index, int length, Encoding encoding);

        //
        // 摘要:
        //     bool变量转化缓存数据，一般来说单bool只能转化为0x01 或是 0x00
        //     The bool variable is converted to cache data, a single bool can only be converted
        //     to 0x01 or 0x00
        //
        // 参数:
        //   value:
        //     等待转化的数据
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(bool value);

        //
        // 摘要:
        //     将bool数组变量转化缓存数据，如果数组长度不满足8的倍数，则自动补0操作。
        //     Convert the bool array variable to the cache data. If the length of the array
        //     does not meet a multiple of 8, it will automatically add 0.
        //
        // 参数:
        //   values:
        //     等待转化的数组
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(bool[] values);

        //
        // 摘要:
        //     将byte变量转化缓存数据
        //     Convert byte variables into cached data
        //
        // 参数:
        //   value:
        //     等待转化的数据
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(byte value);

        //
        // 摘要:
        //     short变量转化缓存数据，一个short数据可以转为2个字节的byte数组
        //     Short variable is converted to cache data, a short data can be converted into
        //     a 2-byte byte array
        //
        // 参数:
        //   value:
        //     等待转化的数据
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(short value);

        //
        // 摘要:
        //     short数组变量转化缓存数据，n个长度的short数组，可以转为2*n个长度的byte数组
        //     The short array variable transforms the buffered data, a short array of n lengths
        //     can be converted into a byte array of 2*n lengths
        //
        // 参数:
        //   values:
        //     等待转化的数组
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(short[] values);

        //
        // 摘要:
        //     ushort变量转化缓存数据，一个ushort数据可以转为2个字节的Byte数组
        //     ushort variable converts buffer data, a ushort data can be converted into a 2-byte
        //     Byte array
        //
        // 参数:
        //   value:
        //     等待转化的数据
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(ushort value);

        //
        // 摘要:
        //     ushort数组变量转化缓存数据，n个长度的ushort数组，可以转为2*n个长度的byte数组
        //     The ushort array variable transforms the buffer data, the ushort array of n length
        //     can be converted into a byte array of 2*n length
        //
        // 参数:
        //   values:
        //     等待转化的数组
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(ushort[] values);

        //
        // 摘要:
        //     int变量转化缓存数据，一个int数据可以转为4个字节的byte数组
        //     Int variable converts cache data, an int data can be converted into a 4-byte
        //     byte array
        //
        // 参数:
        //   value:
        //     等待转化的数据
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(int value);

        //
        // 摘要:
        //     int数组变量转化缓存数据，n个长度的int数组，可以转为4*n个长度的byte数组
        //     The int array variable transforms the cache data, the int array of n length can
        //     be converted to the byte array of 4*n length
        //
        // 参数:
        //   values:
        //     等待转化的数组
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(int[] values);

        //
        // 摘要:
        //     uint变量转化缓存数据，一个uint数据可以转为4个字节的byte数组
        //     uint variable converts buffer data, a uint data can be converted into a 4-byte
        //     byte array
        //
        // 参数:
        //   value:
        //     等待转化的数据
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(uint value);

        //
        // 摘要:
        //     uint数组变量转化缓存数据，n个长度的uint数组，可以转为4*n个长度的byte数组
        //     uint array variable converts buffer data, uint array of n length can be converted
        //     to byte array of 4*n length
        //
        // 参数:
        //   values:
        //     等待转化的数组
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(uint[] values);

        //
        // 摘要:
        //     long变量转化缓存数据，一个long数据可以转为8个字节的byte数组
        //     Long variable is converted into cache data, a long data can be converted into
        //     8-byte byte array
        //
        // 参数:
        //   value:
        //     等待转化的数据
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(long value);

        //
        // 摘要:
        //     long数组变量转化缓存数据，n个长度的long数组，可以转为8*n个长度的byte数组
        //     The long array variable transforms the buffer data, the long array of n length
        //     can be converted into the byte array of 8*n length
        //
        // 参数:
        //   values:
        //     等待转化的数组
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(long[] values);

        //
        // 摘要:
        //     ulong变量转化缓存数据，一个ulong数据可以转为8个字节的byte数组
        //     Ulong variable converts cache data, a ulong data can be converted into 8-byte
        //     byte array
        //
        // 参数:
        //   value:
        //     等待转化的数据
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(ulong value);

        //
        // 摘要:
        //     ulong数组变量转化缓存数据，n个长度的ulong数组，可以转为8*n个长度的byte数组
        //     The ulong array variable transforms the buffer data, the ulong array of n length
        //     can be converted to the byte array of 8*n length
        //
        // 参数:
        //   values:
        //     等待转化的数组
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(ulong[] values);

        //
        // 摘要:
        //     float变量转化缓存数据，一个float数据可以转为4个字节的byte数组
        //     Float variable is converted into cache data, a float data can be converted into
        //     a 4-byte byte array
        //
        // 参数:
        //   value:
        //     等待转化的数据
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(float value);

        //
        // 摘要:
        //     float数组变量转化缓存数据，n个长度的float数组，可以转为4*n个长度的byte数组
        //     Float array variable converts buffer data, n-length float array can be converted
        //     into 4*n-length byte array
        //
        // 参数:
        //   values:
        //     等待转化的数组
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(float[] values);

        //
        // 摘要:
        //     double变量转化缓存数据，一个double数据可以转为8个字节的byte数组
        //     The double variable is converted to cache data, a double data can be converted
        //     into an 8-byte byte array
        //
        // 参数:
        //   value:
        //     等待转化的数据
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(double value);

        //
        // 摘要:
        //     double数组变量转化缓存数据，n个长度的double数组，可以转为8*n个长度的byte数组
        //     The double array variable transforms the buffer data, the double array of n length
        //     can be converted to the byte array of 8*n length
        //
        // 参数:
        //   values:
        //     等待转化的数组
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(double[] values);

        //
        // 摘要:
        //     使用指定的编码字符串转化缓存数据
        //     Use the specified encoding string to convert the cached data
        //
        // 参数:
        //   value:
        //     等待转化的数据
        //
        //   encoding:
        //     字符串的编码方式
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(string value, Encoding encoding);

        //
        // 摘要:
        //     使用指定的编码字符串转化缓存数据，指定转换之后的字节长度信息
        //     Use the specified encoding string to convert the cached data, specify the byte
        //     length information after conversion
        //
        // 参数:
        //   value:
        //     等待转化的数据
        //
        //   length:
        //     转换之后的数据长度
        //
        //   encoding:
        //     字符串的编码方式
        //
        // 返回结果:
        //     buffer数据
        byte[] TransByte(string value, int length, Encoding encoding);

        //
        // 摘要:
        //     根据指定的Core.IByteTransform.EndianType格式，来实例化一个新的对象，除了Core.IByteTransform.EndianType不同，其他都相同
        //
        //     According to the specified Core.IByteTransform.EndianType format,
        //     to instantiate a new object, except that Core.IByteTransform.EndianType
        //     is different, everything else is the same
        //
        // 参数:
        //   dataFormat:
        //     数据格式
        //
        // 返回结果:
        //     新的Core.IByteTransform对象
        IByteTransform CreateByDateFormat(EndianType dataFormat);
    }
}
